/*

 * and open the template in the editor.
 */

package hcmus.fit.master.sevensea.bus;

import hcmus.fit.master.sevensea.core.AnimationSprite;
import hcmus.fit.master.sevensea.enumeration.ShipState;

import java.util.ArrayList;
import java.util.List;

import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.Point;

/**
 * 
 * @author hvp
 */
public abstract class Ship extends AnimationSprite {
    protected int status;
    // protected Direction DestDirection;
    protected ShipState state;
    // protected Point destPos;
    // protected double _tempX;
    // protected double _tempY;
    // protected static List ShipWhirl;
    protected List<List<Bitmap>> framesList;

    // public int Delta = 3;

    public Ship(Resources resources, Point p) {
        super(resources, p);
        this.numberOfFrame = getNbOfRow();
        // State = ShipState.IDLE;
        // DestX = x;
        // DestY = y;
        // Status = 4;
        // DestDirection = Direction.RIGHT;
        // FrameLibrary = null;
        // this.resources = resources;
        // _tempX = x * Constant.CellWidth * 1.0;
        // _tempY = y * Constant.CellHeight * 1.0;
    }

    public List<List<Bitmap>> getFramesList() {
        return framesList;
    }

    public void setFramesList(List<List<Bitmap>> framesList) {
        this.framesList = framesList;
    }

    @Override
    protected int getNbOfCol() {
        return 16;
    }

    @Override
    protected int getNbOfRow() {
        return 8;
    }

    @Override
    protected List<Bitmap> createSpriteImage(Bitmap res, int maxX, int maxY) {
        this.framesList = new ArrayList<List<Bitmap>>();
        int w = res.getWidth() / maxX;
        int h = res.getHeight() / maxY;

        for (int i = 0; i < maxX; i++) {
            List<Bitmap> colRes = new ArrayList<Bitmap>();
            for (int j = 0; j < maxY; j++) {
                colRes.add(Bitmap.createBitmap(res, i * w, j * h, w, h));
            }
            this.framesList.add(colRes);
        }
        return this.framesList.get(0);
    }
    // public Ship(Ship ship) {
    // super(ship);
    // State = ship.State;
    // DestX = ship.DestX;
    // DestY = ship.DestY;
    // Status = ship.Status;
    // DestDirection = ship.DestDirection;
    // FrameLibrary = ship.FrameLibrary;
    // _tempX = ship._tempX;
    // _tempY = ship._tempY;
    // Delta = ship.Delta;
    // }

    // @Override
    // public void moveImmediate(Point newPOs) {
    // super.moveImmediate(newPOs);
    // DestX = x;
    // DestY = y;
    // _tempX = x * Constant.CellWidth * 1.0;
    // _tempY = y * Constant.CellHeight * 1.0;
    // }
    //
    // public boolean IsShip() {
    // return true;
    // }
    //
    // // Direction
    // // 7 0 1
    // // 6 2
    // // 5 4 3
    // public void Move() {
    // switch (DestDirection) {
    // case TOP:
    // _tempY -= Constant.ShipMoveDeltaY;
    // break;
    // case TOP_RIGHT:
    // _tempX += Constant.ShipMoveDeltaX;
    // _tempY -= Constant.ShipMoveDeltaY;
    // break;
    // case RIGHT:
    // _tempX += Constant.ShipMoveDeltaX;
    // break;
    // case BOTTOM_RIGHT:
    // _tempX += Constant.ShipMoveDeltaX;
    // _tempY += Constant.ShipMoveDeltaY;
    // break;
    // case BOTTOM:
    // _tempY += Constant.ShipMoveDeltaY;
    // break;
    // case BOTTOM_LEFT:
    // _tempX -= Constant.ShipMoveDeltaX;
    // _tempY += Constant.ShipMoveDeltaY;
    // break;
    // case LEFT:
    // _tempX -= Constant.ShipMoveDeltaX;
    // break;
    // default:
    // _tempX -= Constant.ShipMoveDeltaX;
    // _tempY -= Constant.ShipMoveDeltaY;
    // break;
    // }
    //
    // Position = new Point((int) Math.floor(_tempX), (int) Math.floor(_tempY));
    // }
    //
    // // Direction
    // // 7 0 1
    // // 6 2
    // // 5 4 3
    // public void Rotate() {
    // int direction = DestDirection.getId();
    // int tmp = (Status / 2) - direction;
    // if (tmp < 0) {
    // if (tmp < -4) {
    // Status--;
    // if (Status < 0) {
    // Status = 15;
    // }
    // frames = (List<Bitmap>) FrameLibrary.get(Status);
    //
    // }
    //
    // if (tmp >= -4) {
    // Status = (Status + 1) % 16;
    // frames = (List<Bitmap>) FrameLibrary.get(Status);
    //
    // }
    // } else {
    // if (tmp < 4) {
    // Status--;
    // if (Status < 0) {
    // Status = 15;
    // }
    // frames = (List<Bitmap>) FrameLibrary.get(Status);
    //
    // }
    //
    // if (tmp >= 4) {
    // Status = (Status + 1) % 16;
    // frames = (List<Bitmap>) FrameLibrary.get(Status);
    // }
    // }
    // }
    //
    // public int GetDirection(int destX, int destY, Size size) {
    // int x = (size.width - Constant.CellWidth) / 2;
    // int y = (size.height - Constant.ControlHeight - Constant.CellHeight) / 2;
    //
    // if (destX >= (x - Constant.CellWidth) && destX <= x) {
    // if (destY >= (y - Constant.CellHeight) && destY <= y) {
    // DestDirection = 7;
    // return 7;
    // }
    //
    // if (destY >= y && destY <= (y + Constant.CellHeight)) {
    // DestDirection = 6;
    // return 6;
    // }
    //
    // if (destY >= (y + Constant.CellHeight) && destY <= (y + 2 *
    // Constant.CellHeight)) {
    // DestDirection = 5;
    // return 5;
    // }
    // }
    //
    // if (destX >= x && destX <= (x + Constant.CellWidth)) {
    // if (destY >= (y - Constant.CellHeight) && destY <= y) {
    // DestDirection = 0;
    // return 0;
    // }
    //
    // if (destY >= y && destY <= (y + Constant.CellHeight)) {
    // return -1;
    // }
    //
    // if (destY >= (y + Constant.CellHeight) && destY <= (y + 2 *
    // Constant.CellHeight)) {
    // DestDirection = 4;
    // return 4;
    // }
    // }
    //
    // if (destX >= (x + Constant.CellWidth) && destX <= (x + 2 *
    // Constant.CellWidth)) {
    // if (destY >= (y - Constant.CellHeight) && destY <= y) {
    // DestDirection = 1;
    // return 1;
    // }
    //
    // if (destY >= y && destY <= (y + Constant.CellHeight)) {
    // DestDirection = 2;
    // return 2;
    // }
    //
    // if (destY >= (y + Constant.CellHeight) && destY <= (y + 2 *
    // Constant.CellHeight)) {
    // DestDirection = 3;
    // return 3;
    // }
    // }
    // return -2;
    // }
    //
    // public boolean FinishMove() {
    // if (Position.x == DestX * Constant.CellWidth && Position.y == DestY *
    // Constant.CellHeight) {
    // _tempX = DestX * Constant.CellWidth * 1.0;
    // _tempY = DestY * Constant.CellHeight * 1.0;
    // return true;
    // }
    // return false;
    // }
    //
    // public boolean FinishRotate() {
    // if (Status == (DestDirection * 2)) {
    // return true;
    // }
    // return false;
    // }
    //
    // public void GetDestination() {
    // int direction = DestDirection;
    // switch (direction) {
    // case 0:
    // DestX = X;
    // DestY = (Y - 1 >= 0) ? Y - 1 : Y;
    // break;
    // case 1:
    // DestX = (X + 1 < Constant.Width && Y - 1 >= 0) ? X + 1 : X;
    // DestY = (X + 1 < Constant.Width && Y - 1 >= 0) ? Y - 1 : Y;
    // break;
    // case 2:
    // DestX = (X + 1 < Constant.Width) ? X + 1 : X;
    // DestY = Y;
    // break;
    // case 3:
    // DestX = (X + 1 < Constant.Width && Y + 1 < Constant.Height) ? X + 1 : X;
    // DestY = (X + 1 < Constant.Width && Y + 1 < Constant.Height) ? Y + 1 : Y;
    // break;
    // case 4:
    // DestX = X;
    // DestY = (Y + 1 < Constant.Height) ? Y + 1 : Y;
    // break;
    // case 5:
    // DestX = (X - 1 >= 0 && Y + 1 < Constant.Height) ? X - 1 : X;
    // DestY = (X - 1 >= 0 && Y + 1 < Constant.Height) ? Y + 1 : Y;
    // break;
    // case 6:
    // DestX = (X - 1 >= 0) ? X - 1 : X;
    // DestY = Y;
    // break;
    // default:
    // DestX = (X - 1 >= 0 && Y - 1 >= 0) ? X - 1 : X;
    // DestY = (X - 1 >= 0 && Y - 1 >= 0) ? Y - 1 : Y;
    // break;
    // }
    // }
    //
    // public boolean NextFrame() {
    // switch (State) {
    // case ShipState.Idle:
    // break;
    // case ShipState.Moving:
    // if (FinishMove()) {
    // State = ShipState.Idle;
    // X = (Position.x) / Constant.CellWidth;
    // Y = (Position.y) / Constant.CellHeight;
    // if (SeaMap.Map[Y][X] != null) {
    // if (SeaMap.Map[Y][X].IsIsland() || SeaMap.Map[Y][X].IsRubble()) {
    // SeaMap.BoardControl._Score.SCORE += GetScore();
    // SeaMap.Items.remove(this);
    // SeaMap.CreateExplosion(X, Y);
    // } else if (SeaMap.Map[Y][X].IsShip()) {
    // if (SeaMap.Map[Y][X].equals(SeaMap.MainShip))
    // SeaMap.BoardControl._Score.SCORE += GetScore();
    // else
    // SeaMap.BoardControl._Score.SCORE += GetScore() + ((Ship)
    // SeaMap.Map[Y][X]).GetScore();
    //
    // SeaMap.Items.remove(this);
    // SeaMap.Items.remove(SeaMap.Map[Y][X]);
    // SeaMap.CreateRubble(X, Y);
    // SeaMap.CreateExplosion(X, Y);
    // } else if (SeaMap.Map[Y][X].IsWhirl()) {
    // // move to another place
    // SeaMap.BoardControl._Score.SCORE += GetScore();
    // SeaMap.Items.remove(this);
    // SeaMap.CreateSplash(X, Y);
    // }
    // } else {
    // SeaMap.Map[Y][X] = this;
    // }
    // SeaMap.Busy--;
    // } else {
    // Move();
    // }
    // break;
    // case ShipState.Rotating:
    // if (FinishRotate()) {
    // State = ShipState.Moving;
    // } else {
    // Rotate();
    // }
    // break;
    // }
    // Index = (Index + 1) % NumberOfFrame;
    // return true;
    // }
    //
    // public void DoWhirl() {
    // // Status = 7;
    // frames = (List<Bitmap>) ShipWhirl.get(0);
    // Index = 0;
    // Delta = Math.abs(Delta);
    // State = ShipState.Whirling;
    // }
    //
    // public void StopWhirl() {
    // Status = 4;
    // frames = (List<Bitmap>) FrameLibrary.get(Status);
    // Index = 0;
    // State = ShipState.Idle;
    // SeaMap.Map[Y][X] = this;
    // SeaMap.EnemyMove();
    // }
    //
    // public void GetDirection(int targetX, int targetY) {
    // DestDirection = 0;
    // }
    //
    // public static List GetResource(Bitmap resource, int maxX, int maxY, int
    // numerator, int denominator) {
    // List rs = new ArrayList();
    // // rs.Clear();
    // int w = resource.getWidth() / maxX;
    // int h = resource.getHeight() / maxY;
    // // imgatt.SetColorKey(resource.GetPixel(0, 0), resource.GetPixel(0, 0));
    //
    // for (int i = 0; i < maxX; i++) {
    // List<Bitmap> tmp = new Bitmap[maxY];
    // for (int j = 0; j < maxY; j++) {
    // // tmp[j] = Bitmap.createImage(resource, i * w, j * h, w, h,
    // // Sprite.TRANS_NONE);
    // }
    // rs.add(tmp);
    // }
    // return rs;
    // }
    //
    // public int GetScore() {
    // // throw new Exception("Not Implement");
    // return 0;
    // }
    //
    // public boolean ItemAvailable(int direction) {
    // Point p = GetPosition(direction);
    // if (p.x == -1) {
    // return true;
    // }
    // return SeaMap.Map[p.y][p.x] != null;
    // }
    //
    // public Point GetPosition(int direction) {
    // switch (direction) {
    // case 0:
    // if (Y == 0) {
    // return new Point(-1, -1);
    // }
    // return new Point(X, Y - 1);
    // case 1:
    // if (Y == 0 || X == Constant.Width - 1) {
    // return new Point(-1, -1);
    // }
    // return new Point(X + 1, Y - 1);
    // case 2:
    // if (X == Constant.Width - 1) {
    // return new Point(-1, -1);
    // }
    // return new Point(X + 1, Y);
    // case 3:
    // if (Y == Constant.Height - 1 || X == Constant.Width - 1) {
    // return new Point(-1, -1);
    // }
    // return new Point(X + 1, Y + 1);
    // case 4:
    // if (Y == Constant.Height - 1) {
    // return new Point(-1, -1);
    // }
    // return new Point(X, Y + 1);
    // case 5:
    // if (Y == Constant.Height - 1 || X == 0) {
    // return new Point(-1, -1);
    // }
    // return new Point(X - 1, Y + 1);
    // case 6:
    // if (X == 0) {
    // return new Point(-1, -1);
    // }
    // return new Point(X - 1, Y);
    // case 7:
    // if (Y == 0 || X == 0) {
    // return new Point(-1, -1);
    // }
    // return new Point(X - 1, Y - 1);
    // }
    // return new Point(-1, -1);
    // }
}
